(function() {
	/**
	 * 全局方法入口
	 */
	CS = {};

	/**
	 * 数据处理
	 */
	Ext.apply(CS, {
		/**
		 * 去掉字符串左右空格
		 */
		trim: function(str) {
			return str.replace(/^(\s|\u00A0)+/, '').replace(/(\s|\u00A0)+$/, '');
		},
		/**
		 * 判断字符串是否包含某字符串
		 */
		contains: function(str, searchStr) {
			if (str.indexOf(searchStr) != -1) {
				return true;
			} else {
				return false;
			}
		},
		/**
		 * 是否不为空
		 */
		isNotEmpty: function(value) {
			return !CS.isEmpty(value);
		},
		/**
		 * 是否为空
		 */
		isEmpty: function(value) {
			if (Ext.isString(value)) {
				value = CS.trim(value);
			}

			if (Ext.isEmpty(value)) {
				return true;
			}

			return false;
		},
		/**
		 * 是否不为null和undefined
		 */
		isNotNull: function(value) {
			return !CS.isNull(value);
		},
		/**
		 * 是否为null和undefined
		 */
		isNull: function(value) {
			if (!Ext.isDefined(value) || value == null) {
				return true;
			}

			return false;
		},
		/**
		 * 对象转换成JSON格式字符串
		 */
		toJson: function(obj) {
			return Ext.encode(obj);
		},
		/**
		 * JSON格式字符串转换成对象
		 */
		fromJson: function(json) {
			return Ext.decode(json);
		},
		/**
		 * 复制属性
		 */
		apply: function(object, config, defaults) {
			if (defaults) {
				Ext.applyIf(object, defaults);
			}

			return Ext.apply(object, config);
		},
		/**
		 * 复制已存在的属性
		 */
		applyExist: function(object, config) {
			var property;

			if (object) {
				for (property in config) {
					if (CS.isNotNull(object[property])) {
						object[property] = config[property];
					}
				}
			}

			return object;
		},
		/**
		 * 大小写转换，默认为大写转换
		 */
		toCase: function(value, isLow) {
			if (CS.isNull(value)) {
				return '';
			}

			return (value + '')[isLow ? 'toLowerCase' : 'toUpperCase']();
		},
		/**
		 * 获取布尔值
		 */
		getBoolean: function(value, defaultValue) {
			if (CS.isNull(value)) {
				if (CS.isNotNull(defaultValue)) {
					value = defaultValue;
				} else {
					return false;
				}
			}

			if (CS.toCase(value) === 'TRUE' || value === 'Y' || value === 1 || value === true) {
				return true;
			} else if (CS.toCase(value) === 'FALSE' || value === 'N' || value === 0 || value === false) {
				return false;
			} else {
				return null;
			}
		},
		/**
		 * 是否等于其中某个值
		 */
		equalOne: function(value, arr) {
			for (var i = 0; i < arr.length; i++) {
				if (value === arr[i]) {
					return true;
				}
			}

			return false;
		}
	});

	/**
	 * 配置处理
	 */
	Ext.apply(CS, {
		/**
		 * 转换配置值
		 */
		transConfigValue: function(config) {
			var param;

			for (param in config) {
				if (Ext.isNumeric(config[param])) {
					config[param] *= 1;
				} else if (CS.equalOne(config[param], ['true', 'false'])) {
					config[param] = CS.getBoolean(config[param]);
				}
			}
			return config;
		},
		/**
		 * 转换配置属性名
		 */
		transConfigParam: function(config, transform) {
			var param;

			for (param in transform) {
				var old = transform[param];

				if (CS.isNotNull(config[old])) {
					config[param] = config[old];
					delete config[old];
				}
			}
		},
		/**
		 * 把“key:value,key:value,...”这种类型的字符串转换成对象
		 */
		transKeyValue: function(str) {
			var obj = {}, paramArr = str.split(',');

			Ext.each(paramArr, function(param) {
				var info = param.split(':');
				obj[info[0]] = info[1];
			});

			return obj;
		},
		/**
		 * 设置默认属性
		 */
		setDefaultConfig: function(config, defaultConfig) {
			Ext.applyIf(config, defaultConfig);
		},
		/**
		 * 根据class名称组装数据
		 */
		getPackageData: function(data, clsName, notNeedCls) {
			if (CS.isEmpty(clsName) || notNeedCls == true) {
				return data;
			} else {
				var realData = {};
				realData[clsName] = data;
				return realData;
			}
		},
		/**
		 * 注册控件
		 */
		register: function(config) {
			var param;

			for (param in config) {
				Ext.ClassManager.setAlias(param, config[param]);
			}
		}
	});

	window.rootUrl = window.rootUrl || '';
	window.moduleUrl = window.moduleUrl || '';

	/**
	 * 远程服务
	 */
	Ext.apply(CS, {
		/**
		 * 获取完整路径
		 */
		getUrl: function(url, type) {
			var preUrl;

			url = url || '';

			type = type || 'r';

			switch (type) {
			case 'r':
				preUrl = window.rootUrl;
				break;
			case 'm':
				preUrl = window.moduleUrl;
				break;
			}

			return (preUrl + url).replace(/\/{2,}/g, '/').replace(/\/$/, '');
		},
		/**
		 * 从根路径开始，获取完整路径
		 */
		getRootUrl: function(url) {
			return CS.getUrl(url, 'r');
		},
		/**
		 * 从当前模块路径开始，获取完整路径
		 */
		getModuleUrl: function(url) {
			return CS.getUrl(url, 'm');
		},
		/**
		 * 请求服务器
		 */
		request: function(options) {
			if (options.toModule == true) {
				options.url = CS.getRootUrl(options.url);
			} else {
				options.url = CS.getModuleUrl(options.url);
			}

			var doRequest = function() {
				if (options.ajax == false) {
					if (options.lock) {
						CS.lock('正在跳转，请稍等...', false);
					}
					window.location.href = options.url;
				} else {
					if (options.lock) {
						CS.lock(options.lockMsg);
					}

					function transFn(fn) {
						var newFn;

						if (fn) {
							newFn = function(response, opt) {
								var obj = null;

								if (!CS.isNull(response.responseText)) {
									obj = Ext.decode(response.responseText);
								}

								fn.apply(this, [obj, opt]);

								if (options.lock) {
									CS.unlock();
								}
							};
						}

						return newFn;
					}

					Ext.Ajax.request({
						url: options.url,
						jsonData: options.data,
						success: transFn(options.succ),
						failure: transFn(options.error)
					});
				}
			}

			if (CS.isNotEmpty(options.confirm)) {
				CS.confirm(options.confirm, function() {
					doRequest();
				});
			} else {
				doRequest();
			}
		},
		/**
		 * Ajax请求
		 */
		ajax: function(options) {
			options.ajax = true;
			CS.request(options);
		},
		/**
		 * 提交资源
		 */
		submit: function(options) {
			options.lock = true;
			CS.ajax(options);
		},
		/**
		 * 跳转页面
		 */
		run: function(url, lock) {
			CS.request({
				url: url,
				ajax: false,
				lock: CS.getBoolean(lock, true)
			});
		},
		/**
		 * 把对象转换为“key1=value1&key2=value2...”这样的请求参数格式
		 */
		param: function(obj) {
			var arr = [];

			for ( var prefix in obj) {
				CS.buildParams(prefix, obj[prefix], arr);
			}

			return arr.join("&").replace(/%20/g, '+');
		},
		/**
		 * 把obj以“key=value”格式的字符串放到arr数组中
		 */
		buildParams: function(prefix, obj, arr) {
			if (CS.isNull(obj)) {
				obj = '';
			}

			if (Ext.isArray(obj) && CS.isNotEmpty(obj)) {
				for (var i = 0; i < obj.length; i++) {
					var v = obj[i];
					buildParams(prefix + '[' + (Ext.isObject(v) || Ext.isArray(v) ? i : '') + ']', v, arr);
				}
			} else if (Ext.isObject(v)) {
				for (name in obj) {
					buildParams(prefix + '[' + name + ']', obj[name], arr);
				}
			} else {
				arr[arr.length] = encodeURIComponent(prefix) + '=' + encodeURIComponent(obj);
			}
		}
	});

	/**
	 * 提示框
	 */
	Ext.apply(CS, {
		/**
		 * 警告提示框
		 */
		alert: function() {
			var arg = [{
				title: '提示',
				icon: Ext.Msg.WARNING
			}];

			CS.showMsg.apply(this, arg.concat(Array.prototype.slice.call(arguments, 0)));
		},
		/**
		 * 错误提示框
		 */
		error: function() {
			var arg = [{
				title: '错误',
				icon: Ext.Msg.ERROR
			}];

			CS.showMsg.apply(this, arg.concat(Array.prototype.slice.call(arguments, 0)));
		},
		/**
		 * 信息提示框
		 */
		info: function() {
			var arg = [{
				title: '信息',
				icon: Ext.Msg.INFO
			}];

			CS.showMsg.apply(this, arg.concat(Array.prototype.slice.call(arguments, 0)));
		},
		/**
		 * 信息确认框
		 */
		confirm: function(msg, okFn, cancelFn) {
			var cfg = {
				title: '信息确认',
				icon: Ext.Msg.QUESTION,
				msg: msg,
				buttons: [{
					text: '确定',
					fn: okFn
				}, {
					text: '取消',
					fn: cancelFn
				}]
			};

			CS.complexMsg.apply(this, [cfg]);
		},
		/**
		 * 复杂提示框
		 */
		complexMsg: function(cfg) {
			var buttons = cfg.buttons, buttonNum = {
				1: Ext.Msg.YES,
				2: Ext.Msg.YESNO,
				3: Ext.Msg.YESNOCANCEL
			}, buttonIds = ['yes', 'no', 'cancel'], buttonFn = {};

			cfg.buttons = buttonNum[buttons.length];

			cfg.buttonText = {};
			for (var i = 0; i < 3 && i < buttons.length; i++) {
				var button = buttons[i];
				cfg.buttonText[buttonIds[i]] = button.text;
				buttonFn[buttonIds[i]] = button.fn || Ext.emptyFn;
			}

			cfg.fn = function(buttonId) {
				for (var i = 0; i < buttonIds.length; i++) {
					if (buttonId == buttonIds[i]) {
						buttonFn[buttonIds[i]]();
					}
				}
			};

			var arg = [cfg];

			CS.showMsg.apply(this, [cfg]);
		},
		/**
		 * 基础提示框
		 */
		showMsg: function() {
			var option = arguments[0];

			option.closable = false;

			if (option.wait != true && option.buttons == undefined) {
				option.buttons = Ext.Msg.OK;
			}

			switch (arguments.length) {
			case 2:
				option.msg = arguments[1];
				break;
			case 3:
				if (Ext.isFunction(arguments[2])) {
					option.msg = arguments[1], option.fn = arguments[2];
				} else {
					option.title = arguments[1], option.msg = arguments[2];
				}
				break;
			case 4:
				option.title = arguments[1], option.msg = arguments[2], option.callback = arguments[3];
				break;
			}

			Ext.Msg.show(option);
		},
		/**
		 * 锁屏
		 */
		lock: function(message, unlockable) {
			CS.showMsg({
				isLock: true,
				unlockable: CS.isNull(unlockable) ? true : unlockable,
				msg: message || '正在提交，请稍等...',
				wait: true,
				waitConfig: {
					interval: 200
				}
			});
		},
		/**
		 * 去掉锁屏
		 */
		unlock: function() {
			var cfg = Ext.Msg.cfg;

			if (cfg.isLock && cfg.unlockable) {
				Ext.MessageBox.hide();
			}
		}
	});

	/**
	 * DOM操作
	 */
	Ext.apply(CS, {
		/**
		 * 创建控件
		 */
		create: function(config) {
			return Ext.widget(config);
		},
		/**
		 * 绑定事件
		 */
		bind: function(cmp, eventName, fn, scope) {
			scope = scope || cmp;

			cmp.addListener(eventName, fn, scope);
		}
	});

	/**
	 * 页面静态方法，需要设置mainPanel属性
	 */
	Ext.apply(CS, {
		/**
		 * 主面板
		 */
		mainPanel: undefined,
		/**
		 * 获取页面主面板
		 */
		getMain: function() {
			return CS.mainPanel;
		},
		/**
		 * 获取页面标题
		 */
		getTitle: function() {
			return CS.getMain().pageTitle;
		},
		/**
		 * 获取页面数据
		 */
		getData: function(notNeedCls) {
			return CS.getMain().getData(notNeedCls);
		},
		/**
		 * 设置页面数据
		 */
		setData: function(data, notNeedCls) {
			CS.getMain().setData(data, notNeedCls);
		},
		/**
		 * 清空页面数据
		 */
		clear: function() {
			return CS.getMain().clear();
		},
		/**
		 * 根据ID获取控件
		 */
		get: function(id) {
			return CS.find('#' + id, true);
		},
		/**
		 * 根据选择符查询控件
		 */
		find: function(selector, onlyOne) {
			var arr = Ext.ComponentQuery.query(selector);

			if (CS.isNotEmpty(arr)) {
				if (onlyOne == true) {
					return arr[0];
				} else {
					return arr;
				}
			} else {
				return null;
			}
		},
		/**
		 * 显示控件
		 */
		show: function(comp) {
			if (Ext.isString(comp)) {
				comp = CS.get(comp);
			}

			if (comp) {
				var tabPanel = comp.up('tabpanel', 1);

				if (tabPanel && comp.tab) {
					tabPanel.showTab(comp);
				} else {
					comp.show();
				}
			}
		},
		/**
		 * 隐藏控件
		 */
		hide: function(comp) {
			if (Ext.isString(comp)) {
				comp = CS.get(comp);
			}

			if (comp) {
				var tabPanel = comp.up('tabpanel', 1);

				if (tabPanel && comp.tab) {
					tabPanel.hideTab(comp);
				} else {
					comp.hide();
				}
			}
		},
		/**
		 * 设置只读属性
		 */
		setReadOnly: function(readOnly) {
			return CS.getMain().setReadOnly(readOnly);
		}
	});
})();

Ext.Loader.setPath({
	'CS': CS.getRootUrl('resource/cs/ext/src')
});

/**
 * 注册控件
 */
CS.register({
	/**
	 * 字段
	 */
	'CS.field.BaseField': 'widget.field.base',
	'CS.field.Combo': 'widget.field.combo',
	'CS.field.Date': 'widget.field.date',
	'CS.field.Number': 'widget.field.number',
	'CS.field.Password': 'widget.field.password',
	'CS.field.Text': 'widget.field.text',
	/**
	 * 面板
	 */
	'CS.panel.BasePanel': 'widget.panel.base',
	'CS.panel.EditGrid': 'widget.panel.egrid',
	'CS.panel.Fit': 'widget.panel.fit',
	'CS.panel.Form': 'widget.panel.form',
	'CS.panel.Grid': 'widget.panel.grid',
	'CS.panel.HBox': 'widget.panel.hbox',
	'CS.panel.List': 'widget.panel.list',
	'CS.panel.Multi': 'widget.panel.multi',
	'CS.panel.Pie': 'widget.panel.pie',
	'CS.panel.Tab': 'widget.panel.tab',
	'CS.panel.Tree': 'widget.panel.tree',
	'CS.panel.VBox': 'widget.panel.vbox',
	'CS.panel.View': 'widget.panel.view',
	'CS.panel.Win': 'widget.panel.win',
	/**
	 * 页面
	 */
	'CS.page.Main': 'widget.page.main',
	/**
	 * 代理
	 */
	'CS.data.proxy.Custom': 'proxy.custom',
	/**
	 * 数据渲染
	 */
	'CS.data.reader.Tree': 'reader.tree',
	/**
	 * 插件
	 */
	'CS.plugin.FieldDataDeal': 'plugin.fielddatadeal',
	'CS.plugin.FieldDomDeal': 'plugin.fielddomdeal',
	'CS.plugin.GridRender': 'plugin.gridrender',
	'CS.plugin.PanelDataDeal': 'plugin.paneldatadeal',
	'CS.plugin.PanelDomDeal': 'plugin.paneldomdeal',
});
